package com.test.application.test.mylist;

public class MyList {
    private Object[] array;     // 底层存储数组
    private int size;           // 当前元素个数
    private int capacity;       // 当前数组容量

    // 默认初始容量
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 构造函数，使用默认容量
     */
    public MyList() {
        this(DEFAULT_CAPACITY);
    }

    /**
     * 构造函数，指定初始容量
     * @param initialCapacity 初始容量
     */
    public MyList(int initialCapacity) {
        if (initialCapacity < 0) {
            throw new IllegalArgumentException("容量不能为负数: " + initialCapacity);
        }
        this.capacity = initialCapacity;
        this.size = 0;
        this.array = new Object[capacity];
    }

    /**
     * 在列表末尾添加一个元素
     * @param value 要添加的值
     */
    public void append(Object value) {
        // 检查是否需要扩容
        if (size >= capacity) {
            resize();
        }
        array[size] = value;
        size++;
    }

    /**
     * 移除列表中第一个等于 value 的元素
     * @param value 要移除的值
     * @return true 如果成功移除
     * @throws IllegalArgumentException 如果没有找到该值
     */
    public boolean remove(Object value) {
        for (int i = 0; i < size; i++) {
            if ((value == null && array[i] == null) || 
                (value != null && value.equals(array[i]))) {
                // 找到后，将后面的元素前移
                System.arraycopy(array, i + 1, array, i, size - i - 1);
                size--;
                array[size] = null; // 清理引用，帮助GC
                return true;
            }
        }
        throw new IllegalArgumentException(value + " 不在列表中");
    }

    /**
     * 扩容数组，通常是当前容量的2倍
     */
    private void resize() {
        int newCapacity = capacity * 2;
        Object[] newArray = new Object[newCapacity];
        
        // 复制旧数组的数据到新数组
        System.arraycopy(array, 0, newArray, 0, size);
        
        // 更新引用
        array = newArray;
        capacity = newCapacity;
    }

    /**
     * 获取列表长度
     * @return 元素个数
     */
    public int size() {
        return size;
    }

    /**
     * 检查列表是否为空
     * @return 如果为空返回 true
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 根据索引获取元素
     * @param index 索引
     * @return 对应位置的元素
     * @throws IndexOutOfBoundsException 如果索引越界
     */
    public Object get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("索引越界: " + index);
        }
        return array[index];
    }

    /**
     * 根据索引设置元素
     * @param index 索引
     * @param value 新值
     * @return 旧值
     * @throws IndexOutOfBoundsException 如果索引越界
     */
    public Object set(int index, Object value) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("索引越界: " + index);
        }
        Object oldValue = array[index];
        array[index] = value;
        return oldValue;
    }

    /**
     * 返回列表的字符串表示
     * @return 字符串形式
     */
    @Override
    public String toString() {
        if (size == 0) return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (int i = 0; i < size; i++) {
            sb.append(array[i]);
            if (i < size - 1) {
                sb.append(", ");
            }
        }
        sb.append(']');
        return sb.toString();
    }

    // ------------------------ 使用示例 ------------------------
    public static void main(String[] args) {
        MyList list = new MyList();

        // 测试 append
        list.append("Hello");
        list.append(123);
        list.append(45.6);
        System.out.println(list); // 输出: [Hello, 123, 45.6]

        // 测试 remove
        list.remove(123);
        System.out.println(list); // 输出: [Hello, 45.6]

        // 测试移除不存在的元素
        try {
            list.remove("World");
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage()); // 输出: World 不在列表中
        }

        System.out.println("大小: " + list.size()); // 输出: 大小: 2
        System.out.println("第一个元素: " + list.get(0)); // 输出: 第一个元素: Hello
    }
}